Im Rahmen der Fallstudie auf Seite 9 haben wir die N-Kreuz-N-Matrix ja eigentlich als

eindimensionales offenes Feld verstanden. Das sieht man in der Schnittstelle dieser beiden

Funktionen bei Row und bei Collum, die einfach nur ein Zeiger auf einem Speicherbereich repräsentieren.

Und dieser Speicherbereich dann einfach so groß ist, dass er tatsächlich N-Kreuz-N-Integer-Elemente

unserer Matrix dann aufnimmt. Wir wollen hier im Anhang jetzt eine alternative Implementierung

dieser beiden Funktionen vornehmen und zwar indem wir dann die Matrix wirklich als ein

zweidimensionales offenes Feld begreifen. Nun ist es so, dass offene Felder generell als Datentypen

in C nicht bekannt sind, insbesondere eben auch nicht dynamische Felder. Wir müssen die nachbilden.

Wie wir das auf der Seite 10 schon in 9 schon gesehen haben, gilt das hier genauso. Wir müssen

entsprechend das Zeigernkonzept in C verwenden, um denn letztlich hier so offene Felder in der

zweidimensionalen Repräsentation zu repräsentieren. Und für unsere Matrix ist da hilfreich, wenn wir

uns mal ein Entwurfsbild dieser Datenstruktur anschauen, auf die es dann nachher hinauslaufen

wird. Da haben wir mit MX erstmal den Zeiger, den wir übergeben werden an die beiden Prozeduren,

die dann die Initialisierung dieser N-Kreuz-N-Matrix vornehmen sollen. Und hier ist der Zeiger jetzt

nicht einfach direkt ein Zeiger auf den Speicherbereich, wo die einzelnen Feldelemente

denn wirklich liegen werden, sondern hier ist der Zeiger ein Zeiger auf ein Reihenzeigerfeld.

Technisch gesehen ein Zeiger auf einen Zeiger, weil nämlich in diesem Reihenzeigerfeld Zeiger

drin stecken, die dann jeweils auf eine Reihe, auf eine Zeile unserer zweidimensionalen Matrix

verweisen würden. Würden wir jetzt praktisch diesen Zeiger hier auswählen, also die Adresse

einer Zeile auswählen, dann würde es reichen MX von 0, MX von 1 bis MX vom M-1 halt hinzuschreiben.

Wollen wir tatsächlich denn diese Elemente hier auswählen, dann können wir jetzt tatsächlich

zwei Subskriptoperationen hintereinander formulieren, dann wird die Zuweisung,

semantisch zumindest ein bisschen klarer, die man durchführt, um einzelne Elemente

einer Matrix bestimmten Werte zu geben. Hier zum Beispiel das erste Element unserer

zweidimensionalen Matrix würden wir denn halt selektieren mit MX von 0 von 0, das zweite Element

MX 0 und 1 oder hier das letzte Spalten-Element, der ersten Spalte im Endeffekt MX von M-1 von 0.

Also das ist sozusagen das Modell, das wir vor Augen haben, um jetzt eine alternative

Implementierung anzugeben. Die Implementierung basiert natürlich dann darauf, dass man eben

auch diese N-Kreuz-N-Matrix schon irgendwie anders anlegen muss, als man es vorher in einer

Fallstudie gesehen hat. Hier sieht es so aus, erstmal von den Programmargumenten bleibt es

so wie gehabt. Diese Stelle hier, Zeile 8, legt letztendlich das Reihenzeigerfeld an. Also hier

mit C-Allog holen wir uns einen entsprechend großen Speicherbereich N Einträge von Zeigern

auf Integers. Damit bekommen wir einen Zeiger auf den Zeiger zurück. Wenn das gelungen ist,

dann müssen wir jedes einzelne Element in dieser Reihenzeigertabelle initialisieren. Dann müssen

wir dann praktisch die Adresse einer Zeile eintragen und diese Zeilen legen wir dynamisch an mit C-Allog.

Wir wollen hier N Integer-Elemente in dieser Zeile drin haben, N-Kreuz-N-Matrix. Wir sind jetzt in

der I-Zeile, die wir initialisieren wollen. Dann machen wir ein C-Allog, dann kriegen wir einen Zeiger,

auf den Integer-Pointer letztendlich zurück, den tragen wir in MX von ihr ein. Wenn das gelungen

ist, also wenn wir tatsächlich Speicher bekommen haben, dann machen wir weiter. Haben wir keinen

Speicher bekommen, dann werden wir abbrechen. Dann sagen wir einfach, dass dieser Initialisierungsvorgang

gescheitert ist. Wir brechen die Schleife entsprechend ab. Wir würden hier unten jetzt unsere Funktion

bei Row und bei Coil natürlich auch nur dann aufrufen, wenn die Initialisierung unseres

Reihenzeigerfeldes funktioniert hat. Am Ende, wenn die beiden Prozeduren oder eine, die wir ausgewählt

haben, denn durchgelaufen sind, dann geben wir die Ressourcen wieder frei, den Speicherbereich, den

wir angelegt haben. Wir gehen wieder über dieses Reihenzeigerfeld rüber, schauen nach, ob da denn

entsprechend ein Zeiger für eine Zeile definiert ist. Wenn ja, dann geben wir das Element frei. Wenn

nicht, dann brechen wir einfach ab. Weil wir hier oben ja sehen, dass, so wie wir hier ein Null-Element

eingetragen haben, letztendlich, wir wissen, dass danach keine weitere Allokation von Zeilen

durchgeführt worden ist. So können wir hier abbrechen an dieser Stelle. Dann können wir die

Schleife verlassen und geben wir halt noch das Reihenzeigerfeld letztendlich frei. So würde